import fs from "fs/promises";
import path from "path";

// 1.fs.unlink 删除文件
// 2.fs.stat  判断文件的状态 （创建时间、修改时间，是文件还是文件夹） 也可以判断文件是否存在
// 3.fs.readdir 读取目录  (读取默认是子集)
// 4.fs.rmdir 删除目录 (默认无法删除子目录， 如果高版本中可采用recursive：true)
// fs.unlinkSync(path.resolve(import.meta.dirname, "test.md"));

// const statObj = fs.statSync(path.resolve(import.meta.dirname, "dir"));
// console.log(statObj.isFile(), statObj.isDirectory());

// const dirs = fs.readdirSync(path.resolve(import.meta.dirname, "dir"));
// console.log(dirs);

// fs.rmdirSync(path.resolve(import.meta.dirname, "dir"), { recursive: true });

// 1.同步删除，性能差  递归：不停的创建调用栈
function rmdirSync1(dir) {
  const statObj = fs.statSync(dir);
  if (statObj.isFile()) {
    return fs.unlinkSync(dir);
  } else {
    let dirs = fs.readdirSync(dir);
    //  需要看是否有儿子，有儿子先删除儿子
    dirs = dirs.map((p) => {
      const childPath = path.join(dir, p);
      const statObj = fs.statSync(childPath);
      //  判断当前节点是文件，则直接删除即可
      if (statObj.isFile()) {
        return fs.unlinkSync(childPath);
      } else {
        rmdirSync(childPath);
      }
    });
    fs.rmdirSync(dir);
  }
}

// 2.通过栈的方式优化

// function rmdirSync2(dir) {
//   let stack = [dir];
//   let index = 0;
//   let currentDir;
//   while ((currentDir = stack[index++])) {
//     const statObj = fs.statSync(currentDir);
//     if (statObj.isFile()) {
//       fs.unlinkSync(currentDir);
//     } else {
//       stack = [
//         ...stack,
//         ...fs.readdirSync(currentDir).map((p) => path.join(currentDir, p)),
//       ];
//     }
//   }
//   console.log(stack); // 倒序删除， 避免递归 （层序遍历）
//   // vue 菜单权限 【a,b,c,d,e】
// }

// 2.异步删除 (删除的 时候可以采用先序遍历，串行执行)
function rmdirSeries(dir, cb) {
  fs.stat(dir, function (err, statObj) {
    if (err) return cb(err);
    if (statObj.isFile()) {
      fs.unlink(dir, cb);
    } else {
      // a  [a/b  a/d]
      fs.readdir(dir, function (err, dirs) {
        dirs = dirs.map((p) => path.join(dir, p));
        let index = 0; // 这个index是记录删除了几个儿子了
        function next() {
          if (dirs.length === index) {
            // 当子节点全部删除后删除自己
            return fs.rmdir(dir, cb);
          }
          let childPath = dirs[index++];
          rmdirSeries(childPath, next); // 串行删除子节点
        }
        next();
      });
    }
  });
}

function rmdirParall(dir, cb) {
  fs.stat(dir, function (err, statObj) {
    if (err) return cb(err);
    if (statObj.isFile()) {
      fs.unlink(dir, cb);
    } else {
      // a  [a/b  a/d]
      fs.readdir(dir, function (err, dirs) {
        dirs = dirs.map((p) => path.join(dir, p));
        let times = 0;
        if (dirs.length === 0) {
          return fs.rmdir(dir, cb);
        }
        function done() {
          if (++times === dirs.length) {
            // 子节点都删除成功后
            return fs.rmdir(dir, cb);
          }
        }
        dirs.forEach((childPath) => rmdirParall(childPath, done));
      });
    }
  });
}

// function rmdirPromise(dir, cb) {
//   return new Promise((resolve, reject) => {
//     fs.stat(dir, function (err, statObj) {
//       if (err) return reject(err);
//       if (statObj.isFile()) {
//         fs.unlink(dir, resolve);
//       } else {
//         // a  [a/b  a/d]
//         fs.readdir(dir, function (err, dirs) {
//           Promise.all(dirs.map((p) => rmdirPromise(path.join(dir, p)))).then(
//             () => {
//               fs.rmdir(dir, resolve);
//             }
//           );
//         });
//       }
//     });
//   });
// }

async function rmdir(dir) {
  let statObj = await fs.stat(dir);
  if (statObj.isFile()) {
    return fs.unlink(dir);
  } else {
    const dirs = await fs.readdir(dir);
    await Promise.all(dirs.map((p) => rmdir(path.join(dir, p))));
    return fs.rmdir(dir);
  }
}
rmdir(path.resolve(import.meta.dirname, "a")).then(function () {
  console.log("删除成功");
});

// fs/promises 来取代掉 fs.readFile(function(){})
